﻿// clases de la FCL
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
// clases de entidad
using PDS_ANDU.DTO;
using PDS_ANDU.Entidades;
// DAO
using PDS_ANDU.DAO;

namespace PDS_ANDU.Controles
{
    /// <summary>
    /// Control para el manejo de perfiles creados
    /// por los suscriptores
    /// </summary>
    public class ControlPerfil
    {
        /// <summary>
        /// Constructor de clase.
        /// </summary>
        public ControlPerfil()
        {
        } // fin del constructor

        public DTOPerfil[] obtenerPerfiles(string usuario)
        {
            // TODO: crear método obtenerPerfiles en DAO
            List<Perfil> perfiles = DAO.DAO.obtenerPerfiles(usuario);
            DTOPerfil[] dtoPerfiles = new DTOPerfil[perfiles.Count];

            for (int i = 0; i < perfiles.Count; i++)
            {
                // lista de nombres de categorias
                string[] categorias = new string[perfiles[i].Categorias.Count];

                for(int j=0; j<perfiles[i].Categorias.Count; j++)
                {
                    categorias[j] = perfiles[i].Categorias[j].Nombre;
                }

                // instancia nueva de DTOPerfil
                DTOPerfil nuevo = new DTOPerfil(perfiles[i].Numero, perfiles[i].Nombre, categorias);
                dtoPerfiles[i] = nuevo;
            }

            // retorna la lista de perfiles
            return dtoPerfiles;
        } // fin del método obtenerPerfiles

        /// <summary>
        /// Obtiene todos los deportes disponibles en la base de datos.
        /// </summary>
        /// <returns></returns>
        public DTOCategoria[] obtenerDeportes()
        {
            // obtiene una lista de deportes
            List<Deporte> listaDeportes = DAO.DAO.getDeportes();
            // crea los DTOs para enviar a la interfaz
            DTOCategoria[] deportes = new DTOCategoria[listaDeportes.Count];

            for (int i = 0; i < listaDeportes.Count; i++)
            {
                deportes[i] = new DTOCategoria(listaDeportes.ElementAt(i).Nombre, listaDeportes.ElementAt(i).Id_deporte, listaDeportes.ElementAt(i).Id_categoria);
            }

            return deportes;
        } // fin del método obtenerDeportes

        /// <summary>
        /// Obtiene todos los torneos disponibles en la base de datos.
        /// </summary>
        /// <returns></returns>
        public DTOCategoria[] obtenerTorneos()
        {
            // obtiene una lista de torneos
            List<Torneo> listaTorneos = DAO.DAO.getTorneos();
            // crea los DTOs para enviar a la interfaz
            DTOCategoria[] torneos = new DTOCategoria[listaTorneos.Count];

            for (int i = 0; i < listaTorneos.Count; i++)
            {
                torneos[i] = new DTOCategoria(listaTorneos.ElementAt(i).Nombre, listaTorneos.ElementAt(i).Id_torneo, listaTorneos.ElementAt(i).Id_categoria);
            }

            return torneos;
        } // fin del método obtenerTorneos

        /// <summary>
        /// Obtiene todos los equipos disponibles en la base de datos.
        /// </summary>
        /// <returns></returns>
        public DTOCategoria[] obtenerEquipos()
        {
            // obtiene una lista de equipos
            List<Equipo> listaEquipos = DAO.DAO.getEquipos();
            // crea los DTOs para enviar a la interfaz
            DTOCategoria[] equipos = new DTOCategoria[listaEquipos.Count];

            for (int i = 0; i < listaEquipos.Count; i++)
            {
                equipos[i] = new DTOCategoria(listaEquipos.ElementAt(i).Nombre, listaEquipos.ElementAt(i).Id_equipo, listaEquipos.ElementAt(i).Id_categoria);
            }

            return equipos;
        } // fin del método obtenerEquipos

        /// <summary>
        /// Obtiene todos los deportistas disponibles en la base de datos.
        /// </summary>
        /// <returns></returns>
        public DTOCategoria[] obtenerDeportistas()
        {
            // obtiene una lista de deportistas
            List<Deportista> listaDeportistas = DAO.DAO.getDeportistas();
            // crea los DTOs para enviar a la interfaz
            DTOCategoria[] deportistas = new DTOCategoria[listaDeportistas.Count];

            for (int i = 0; i < listaDeportistas.Count; i++)
            {
                deportistas[i] = new DTOCategoria(listaDeportistas.ElementAt(i).Nombre + " " + listaDeportistas.ElementAt(i).Apellido, listaDeportistas.ElementAt(i).Id_deportista, listaDeportistas.ElementAt(i).Id_categoria);
            }

            return deportistas;
        } // fin del método obtenerDeportistas

        /// <summary>
        /// Verifica que el usuario no creó un perfil con el nombre especificado.
        /// </summary>
        /// <param name="nombreUsuario"></param>
        /// <param name="nombrePerfil"></param>
        /// <returns></returns>
        public bool existePerfil(string nombreUsuario, string nombrePerfil)
        {
            return DAO.DAO.existePerfil(nombreUsuario, nombrePerfil);
        } // fin del método existePerfil

        /// <summary>
        /// Crea un nuevo perfil de usuario.
        /// </summary>
        /// <param name="usuario"></param>
        /// <param name="nombrePerfil"></param>
        /// <param name="deportes"></param>
        /// <param name="torneos"></param>
        /// <param name="equipos"></param>
        /// <param name="deportistas"></param>
        public void crearPerfil(string usuario, string nombrePerfil, DTOCategoria[] deportes, DTOCategoria[] torneos, DTOCategoria[] equipos, DTOCategoria[] deportistas)
        {
            // crea los arreglos de entidades
            Deporte[] eDeportes = new Deporte[deportes.Length];
            Torneo[] eTorneos = new Torneo[torneos.Length];
            Equipo[] eEquipos = new Equipo[equipos.Length];
            Deportista[] eDeportistas = new Deportista[deportistas.Length];

            // crea una lista con categorías
            List<Categoria> categorias = new List<Categoria>();

            // crea las instancias de Deporte - 1er loop
            for (int i = 0; i < deportes.Length; i++)
            {
                categorias.Add(new Deporte(deportes[i].Id, deportes[i].Nombre, deportes[i].Id_categoria));
            }

            // crea las instancias de Torneos - 2do loop
            for (int i = 0; i < torneos.Length; i++)
            {
                categorias.Add(eTorneos[i] = new Torneo(torneos[i].Id, torneos[i].Nombre, torneos[i].Id_categoria));
            }

            // crea las instancias de Equipos - 3ro loop
            for (int i = 0; i < equipos.Length; i++)
            {
                categorias.Add(eEquipos[i] = new Equipo(equipos[i].Id, equipos[i].Nombre, equipos[i].Id_categoria));
            }

            // crea las instancias de Deportistas - 4to loop
            for (int i = 0; i < deportistas.Length; i++)
            {
                categorias.Add(eDeportistas[i] = new Deportista(deportistas[i].Id, deportistas[i].Nombre, "" , deportistas[i].Id_categoria));
            }

            //crea una instancia de suscriptor
            Suscriptor suscriptor = new Suscriptor(usuario);
            // crea una instancia de perfil
            Perfil nuevoPerfil = new Perfil(nombrePerfil, suscriptor, categorias);

            try
            {
                // solicita al DAO que almacene los perfiles
                DAO.DAO.persistirPerfil(nuevoPerfil);
            }
            catch (Exception ex)
            {
                throw ex;
            }

        } // fin del método crearPerfil

    } // fin de clase ControlPerfil
}
